if (value_a == NULL || value_b == NULL)
return FALSE;
+ if (value_a->value_class->equal == NULL)
+ return FALSE;
+
return value_a->value_class->equal (value_a, value_b);
}
-/* {{{ Basic types */
+/* {{{ Basic allocated types */
typedef struct {
GtkAccessibleValue parent;
}
static const GtkAccessibleValueClass GTK_INT_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_INTEGER,
.type_name = "GtkIntAccessibleValue",
.instance_size = sizeof (GtkIntAccessibleValue),
.equal = gtk_int_accessible_value_equal,
}
static const GtkAccessibleValueClass GTK_NUMBER_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_NUMBER,
.type_name = "GtkNumberAccessibleValue",
.instance_size = sizeof (GtkNumberAccessibleValue),
.equal = gtk_number_accessible_value_equal,
}
static const GtkAccessibleValueClass GTK_STRING_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_STRING,
.type_name = "GtkStringAccessibleValue",
.instance_size = sizeof (GtkStringAccessibleValue),
.finalize = gtk_string_accessible_value_finalize,
}
static const GtkAccessibleValueClass GTK_REFERENCE_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_REFERENCE,
.type_name = "GtkReferenceAccessibleValue",
.instance_size = sizeof (GtkReferenceAccessibleValue),
.finalize = gtk_reference_accessible_value_finalize,
/* {{{ Collection API */
typedef enum {
- GTK_ACCESSIBLE_COLLECT_INVALID,
- GTK_ACCESSIBLE_COLLECT_BOOLEAN,
- GTK_ACCESSIBLE_COLLECT_INT,
+ GTK_ACCESSIBLE_COLLECT_INVALID = -1,
+
+ /* true/false */
+ GTK_ACCESSIBLE_COLLECT_BOOLEAN = 0,
+
+ /* true/false/mixed/undefined */
GTK_ACCESSIBLE_COLLECT_TRISTATE,
- GTK_ACCESSIBLE_COLLECT_ENUM,
+
+ /* one token */
+ GTK_ACCESSIBLE_COLLECT_TOKEN,
+
+ /* integer number */
+ GTK_ACCESSIBLE_COLLECT_INTEGER,
+
+ /* real number */
GTK_ACCESSIBLE_COLLECT_NUMBER,
+
+ /* string */
GTK_ACCESSIBLE_COLLECT_STRING,
- GTK_ACCESSIBLE_COLLECT_REF
+
+ /* reference */
+ GTK_ACCESSIBLE_COLLECT_REFERENCE,
+
+ /* allows collecting GTK_ACCESSIBLE_VALUE_UNDEFINED; implied
+ * by GTK_ACCESSIBLE_COLLECT_TRISTATE
+ */
+ GTK_ACCESSIBLE_COLLECT_UNDEFINED = 1 << 16
} GtkAccessibleCollectType;
typedef struct {
int value;
GtkAccessibleCollectType ctype;
const char *name;
+
+ /* The constructor and getter will be derived by the
+ * @ctype field and by the collected value, except for the
+ * GTK_ACCESSIBLE_COLLECT_TOKEN collection type. You can
+ * override the default ones by filling out these two
+ * pointers
+ */
GCallback ctor;
+ GCallback getter;
} GtkAccessibleCollect;
static const GtkAccessibleCollect collect_states[] = {
-/* | State | Collected type | Name | Constructor |
- * |-------------------------------|--------------------------------|-----------|----------------------------------|
- */
- { GTK_ACCESSIBLE_STATE_BUSY, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "busy", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_STATE_CHECKED, GTK_ACCESSIBLE_COLLECT_ENUM, "checked", (GCallback) gtk_checked_accessible_value_new },
- { GTK_ACCESSIBLE_STATE_DISABLED, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "disabled", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_STATE_EXPANDED, GTK_ACCESSIBLE_COLLECT_TRISTATE, "expanded", (GCallback) gtk_expanded_accessible_value_new },
- { GTK_ACCESSIBLE_STATE_HIDDEN, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "hidden", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_STATE_INVALID, GTK_ACCESSIBLE_COLLECT_ENUM, "invalid", (GCallback) gtk_invalid_accessible_value_new },
- { GTK_ACCESSIBLE_STATE_PRESSED, GTK_ACCESSIBLE_COLLECT_ENUM, "pressed", (GCallback) gtk_pressed_accessible_value_new },
- { GTK_ACCESSIBLE_STATE_SELECTED, GTK_ACCESSIBLE_COLLECT_TRISTATE, "selected", (GCallback) gtk_selected_accessible_value_new },
+ [GTK_ACCESSIBLE_STATE_BUSY] = {
+ .value = GTK_ACCESSIBLE_STATE_BUSY,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "busy"
+ },
+ [GTK_ACCESSIBLE_STATE_CHECKED] = {
+ .value = GTK_ACCESSIBLE_STATE_CHECKED,
+ .ctype = GTK_ACCESSIBLE_COLLECT_TRISTATE,
+ .name = "checked"
+ },
+ [GTK_ACCESSIBLE_STATE_DISABLED] = {
+ .value = GTK_ACCESSIBLE_STATE_DISABLED,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "disabled"
+ },
+ [GTK_ACCESSIBLE_STATE_EXPANDED] = {
+ .value = GTK_ACCESSIBLE_STATE_EXPANDED,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN | GTK_ACCESSIBLE_COLLECT_UNDEFINED,
+ .name = "expanded"
+ },
+ [GTK_ACCESSIBLE_STATE_HIDDEN] = {
+ .value = GTK_ACCESSIBLE_STATE_HIDDEN,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "hidden"
+ },
+ [GTK_ACCESSIBLE_STATE_INVALID] = {
+ .value = GTK_ACCESSIBLE_STATE_INVALID,
+ .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN,
+ .name = "invalid",
+ .ctor = (GCallback) gtk_invalid_accessible_value_new,
+ .getter = (GCallback) gtk_invalid_accessible_value_get
+ },
+ [GTK_ACCESSIBLE_STATE_PRESSED] = {
+ .value = GTK_ACCESSIBLE_STATE_PRESSED,
+ .ctype = GTK_ACCESSIBLE_COLLECT_TRISTATE,
+ .name = "pressed"
+ },
+ [GTK_ACCESSIBLE_STATE_SELECTED] = {
+ .value = GTK_ACCESSIBLE_STATE_SELECTED,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN | GTK_ACCESSIBLE_COLLECT_UNDEFINED,
+ .name = "selected"
+ },
};
/* § 6.6.1 Widget attributes */
static const GtkAccessibleCollect collect_props[] = {
- { GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE, GTK_ACCESSIBLE_COLLECT_ENUM, "autocomplete", (GCallback) gtk_autocomplete_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_DESCRIPTION, GTK_ACCESSIBLE_COLLECT_STRING, "description", (GCallback) gtk_string_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_HAS_POPUP, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "haspopup", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS, GTK_ACCESSIBLE_COLLECT_STRING, "keyshortcuts", (GCallback) gtk_string_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_LABEL, GTK_ACCESSIBLE_COLLECT_STRING, "label", (GCallback) gtk_string_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_LEVEL, GTK_ACCESSIBLE_COLLECT_INT, "level", (GCallback) gtk_int_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_MODAL, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "modal", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_MULTI_LINE, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "multiline", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "multiselectable", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_ORIENTATION, GTK_ACCESSIBLE_COLLECT_ENUM, "orientation", (GCallback) gtk_orientation_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER, GTK_ACCESSIBLE_COLLECT_STRING, "placeholder", (GCallback) gtk_string_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_READ_ONLY, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "readonly", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_REQUIRED, GTK_ACCESSIBLE_COLLECT_BOOLEAN, "required", (GCallback) gtk_boolean_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION, GTK_ACCESSIBLE_COLLECT_STRING, "roledescription", (GCallback) gtk_string_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_SORT, GTK_ACCESSIBLE_COLLECT_ENUM, "sort", (GCallback) gtk_sort_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_VALUE_MAX, GTK_ACCESSIBLE_COLLECT_NUMBER, "valuemax", (GCallback) gtk_number_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_VALUE_MIN, GTK_ACCESSIBLE_COLLECT_NUMBER, "valuemin", (GCallback) gtk_number_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_VALUE_NOW, GTK_ACCESSIBLE_COLLECT_NUMBER, "valuenow", (GCallback) gtk_number_accessible_value_new },
- { GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT, GTK_ACCESSIBLE_COLLECT_STRING, "valuetext", (GCallback) gtk_string_accessible_value_new },
+ [GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE,
+ .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN,
+ .name = "autocomplete",
+ .ctor = (GCallback) gtk_autocomplete_accessible_value_new,
+ .getter = (GCallback) gtk_autocomplete_accessible_value_get
+ },
+ [GTK_ACCESSIBLE_PROPERTY_DESCRIPTION] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_DESCRIPTION,
+ .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
+ .name = "description"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_HAS_POPUP] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_HAS_POPUP,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "haspopup"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS,
+ .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
+ .name = "keyshortcuts"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_LABEL] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_LABEL,
+ .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
+ .name = "label"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_LEVEL] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_LEVEL,
+ .ctype = GTK_ACCESSIBLE_COLLECT_INTEGER,
+ .name = "level"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_MODAL] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_MODAL,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "modal"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_MULTI_LINE] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_MULTI_LINE,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "multiline"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "multiselectable"
+ },
+ /* "orientation" is a bit special; it maps to GtkOrientation, but it
+ * can also be "undefined". This means we need to override constructor
+ * and getter, in order to properly handle GTK_ACCESSIBLE_VALUE_UNDEFINED
+ */
+ [GTK_ACCESSIBLE_PROPERTY_ORIENTATION] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_ORIENTATION,
+ .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN | GTK_ACCESSIBLE_COLLECT_UNDEFINED,
+ .name = "orientation",
+ .ctor = (GCallback) gtk_orientation_accessible_value_new,
+ .getter = (GCallback) gtk_orientation_accessible_value_get
+ },
+ [GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER,
+ .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
+ .name = "placeholder"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_READ_ONLY] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_READ_ONLY,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "readonly"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_REQUIRED] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_REQUIRED,
+ .ctype = GTK_ACCESSIBLE_COLLECT_BOOLEAN,
+ .name = "required"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION,
+ .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
+ .name = "roledescription"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_SORT] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_SORT,
+ .ctype = GTK_ACCESSIBLE_COLLECT_TOKEN,
+ .name = "sort",
+ .ctor = (GCallback) gtk_sort_accessible_value_new,
+ .getter = (GCallback) gtk_sort_accessible_value_get
+ },
+ [GTK_ACCESSIBLE_PROPERTY_VALUE_MAX] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_VALUE_MAX,
+ .ctype = GTK_ACCESSIBLE_COLLECT_NUMBER,
+ .name = "valuemax"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_VALUE_MIN] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_VALUE_MIN,
+ .ctype = GTK_ACCESSIBLE_COLLECT_NUMBER,
+ .name = "valuemin"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_VALUE_NOW] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_VALUE_NOW,
+ .ctype = GTK_ACCESSIBLE_COLLECT_NUMBER,
+ .name = "valuenow"
+ },
+ [GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT] = {
+ .value = GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT,
+ .ctype = GTK_ACCESSIBLE_COLLECT_STRING,
+ .name = "valuetext"
+ },
};
typedef GtkAccessibleValue * (* GtkAccessibleValueBooleanCtor) (gboolean value);
return gtk_boolean_accessible_value_new (FALSE);
case GTK_ACCESSIBLE_STATE_CHECKED:
- return gtk_checked_accessible_value_new (GTK_ACCESSIBLE_CHECKED_UNDEFINED);
-
case GTK_ACCESSIBLE_STATE_EXPANDED:
- return gtk_expanded_accessible_value_new (GTK_ACCESSIBLE_VALUE_UNDEFINED);
+ case GTK_ACCESSIBLE_STATE_PRESSED:
+ case GTK_ACCESSIBLE_STATE_SELECTED:
+ return gtk_undefined_accessible_value_new ();
case GTK_ACCESSIBLE_STATE_INVALID:
return gtk_invalid_accessible_value_new (GTK_ACCESSIBLE_INVALID_FALSE);
- case GTK_ACCESSIBLE_STATE_PRESSED:
- return gtk_pressed_accessible_value_new (GTK_ACCESSIBLE_PRESSED_UNDEFINED);
-
- case GTK_ACCESSIBLE_STATE_SELECTED:
- return gtk_selected_accessible_value_new (GTK_ACCESSIBLE_VALUE_UNDEFINED);
-
default:
g_critical ("Unknown value for accessible state “%s”", cstate->name);
break;
return NULL;
}
-/*< private >
- * gtk_accessible_value_collect_for_state:
- * @state: a #GtkAccessibleState
- * @args: a `va_list` reference
- *
- * Collects and consumes the next item in the @args variadic arguments list,
- * and returns a #GtkAccessibleValue for it.
- *
- * Returns: (transfer full): a #GtkAccessibleValue
- */
-GtkAccessibleValue *
-gtk_accessible_value_collect_for_state (GtkAccessibleState state,
- va_list *args)
+static GtkAccessibleValue *
+gtk_accessible_value_collect_valist (const GtkAccessibleCollect *cstate,
+ va_list *args)
{
- const GtkAccessibleCollect *cstate = &collect_states[state];
-
GtkAccessibleValue *res = NULL;
+ GtkAccessibleCollectType ctype = cstate->ctype;
+ gboolean collects_undef = (ctype & GTK_ACCESSIBLE_COLLECT_UNDEFINED) != 0;
+
+ ctype &= (GTK_ACCESSIBLE_COLLECT_UNDEFINED - 1);
- switch (cstate->ctype)
+ /* Tristate values include "undefined" by definition */
+ if (ctype == GTK_ACCESSIBLE_COLLECT_TRISTATE)
+ collects_undef = TRUE;
+
+ switch (ctype)
{
case GTK_ACCESSIBLE_COLLECT_BOOLEAN:
{
- GtkAccessibleValueBooleanCtor ctor =
- (GtkAccessibleValueBooleanCtor) cstate->ctor;
-
- gboolean value = va_arg (*args, gboolean);
-
- res = (* ctor) (value);
+ if (collects_undef)
+ {
+ int value = va_arg (*args, int);
+
+ if (value == GTK_ACCESSIBLE_VALUE_UNDEFINED)
+ res = gtk_undefined_accessible_value_new ();
+ else
+ res = gtk_boolean_accessible_value_new (value == 0 ? FALSE : TRUE);
+ }
+ else
+ {
+ gboolean value = va_arg (*args, gboolean);
+
+ res = gtk_boolean_accessible_value_new (value);
+ }
}
break;
- case GTK_ACCESSIBLE_COLLECT_INT:
+ case GTK_ACCESSIBLE_COLLECT_TRISTATE:
{
- GtkAccessibleValueIntCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
-
int value = va_arg (*args, int);
- res = (* ctor) (value);
+ if (value == GTK_ACCESSIBLE_VALUE_UNDEFINED)
+ res = gtk_undefined_accessible_value_new ();
+ else
+ res = gtk_tristate_accessible_value_new (value);
}
break;
- case GTK_ACCESSIBLE_COLLECT_TRISTATE:
+ case GTK_ACCESSIBLE_COLLECT_TOKEN:
{
- GtkAccessibleValueTristateCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
+ GtkAccessibleValueEnumCtor ctor =
+ (GtkAccessibleValueEnumCtor) cstate->ctor;
int value = va_arg (*args, int);
- res = (* ctor) (value);
+ if (collects_undef && value == GTK_ACCESSIBLE_VALUE_UNDEFINED)
+ {
+ res = gtk_undefined_accessible_value_new ();
+ }
+ else
+ {
+ /* Token collection requires a constructor */
+ g_assert (ctor != NULL);
+
+ res = (* ctor) (value);
+ }
}
break;
- case GTK_ACCESSIBLE_COLLECT_ENUM:
+ case GTK_ACCESSIBLE_COLLECT_INTEGER:
{
GtkAccessibleValueEnumCtor ctor =
(GtkAccessibleValueEnumCtor) cstate->ctor;
int value = va_arg (*args, int);
- res = (* ctor) (value);
+ if (ctor == NULL)
+ res = gtk_int_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
double value = va_arg (*args, double);
- res = (* ctor) (value);
+ if (ctor == NULL)
+ res = gtk_number_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
const char *value = va_arg (*args, char*);
- res = (* ctor) (value);
+ if (ctor == NULL)
+ res = gtk_string_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
- case GTK_ACCESSIBLE_COLLECT_REF:
+ case GTK_ACCESSIBLE_COLLECT_REFERENCE:
{
GtkAccessibleValueStringCtor ctor =
(GtkAccessibleValueStringCtor) cstate->ctor;
gpointer value = va_arg (*args, gpointer);
- res = (* ctor) (value);
+ if (ctor == NULL)
+ res = gtk_reference_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
+ case GTK_ACCESSIBLE_COLLECT_UNDEFINED:
case GTK_ACCESSIBLE_COLLECT_INVALID:
default:
g_critical ("Unknown type for accessible state “%s”", cstate->name);
return res;
}
-/*< private >
- * gtk_accessible_value_collect_for_state_value:
- * @state: a #GtkAccessibleState
- * @value: a #GValue
- *
- * Retrieves the value stored inside @value and returns a #GtkAccessibleValue
- * for the given @state.
- *
- * Returns: (transfer full): a #GtkAccessibleValue
- */
-GtkAccessibleValue *
-gtk_accessible_value_collect_for_state_value (GtkAccessibleState state,
- const GValue *value)
+static GtkAccessibleValue *
+gtk_accessible_value_collect_value (const GtkAccessibleCollect *cstate,
+ const GValue *value_)
{
- const GtkAccessibleCollect *cstate = &collect_states[state];
-
GtkAccessibleValue *res = NULL;
+ GtkAccessibleCollectType ctype = cstate->ctype;
+ gboolean collects_undef = (ctype & GTK_ACCESSIBLE_COLLECT_UNDEFINED) != 0;
+
+ ctype &= (GTK_ACCESSIBLE_COLLECT_UNDEFINED - 1);
- switch (cstate->ctype)
+ /* Tristate values include "undefined" by definition */
+ if (ctype == GTK_ACCESSIBLE_COLLECT_TRISTATE)
+ collects_undef = TRUE;
+
+ switch (ctype)
{
case GTK_ACCESSIBLE_COLLECT_BOOLEAN:
{
- GtkAccessibleValueBooleanCtor ctor =
- (GtkAccessibleValueBooleanCtor) cstate->ctor;
-
- gboolean value_ = g_value_get_boolean (value);
-
- res = (* ctor) (value_);
+ if (collects_undef)
+ {
+ int value = g_value_get_int (value_);
+
+ if (value == GTK_ACCESSIBLE_VALUE_UNDEFINED)
+ res = gtk_undefined_accessible_value_new ();
+ else
+ res = gtk_boolean_accessible_value_new (value == 0 ? FALSE : TRUE);
+ }
+ else
+ {
+ gboolean value = g_value_get_boolean (value_);
+
+ res = gtk_boolean_accessible_value_new (value);
+ }
}
break;
- case GTK_ACCESSIBLE_COLLECT_INT:
+ case GTK_ACCESSIBLE_COLLECT_TRISTATE:
{
- GtkAccessibleValueIntCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
+ int value = g_value_get_int (value_);
- int value_ = g_value_get_int (value);
-
- res = (* ctor) (value_);
+ if (value == GTK_ACCESSIBLE_VALUE_UNDEFINED)
+ res = gtk_undefined_accessible_value_new ();
+ else
+ res = gtk_tristate_accessible_value_new (value);
}
break;
- case GTK_ACCESSIBLE_COLLECT_TRISTATE:
+ case GTK_ACCESSIBLE_COLLECT_TOKEN:
{
- GtkAccessibleValueTristateCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
+ GtkAccessibleValueEnumCtor ctor =
+ (GtkAccessibleValueEnumCtor) cstate->ctor;
- int value_ = g_value_get_int (value);
+ int value = g_value_get_int (value_);
- res = (* ctor) (value_);
+ if (collects_undef && value == GTK_ACCESSIBLE_VALUE_UNDEFINED)
+ {
+ res = gtk_undefined_accessible_value_new ();
+ }
+ else
+ {
+ /* Token collection requires a constructor */
+ g_assert (ctor != NULL);
+
+ res = (* ctor) (value);
+ }
}
break;
- case GTK_ACCESSIBLE_COLLECT_ENUM:
+ case GTK_ACCESSIBLE_COLLECT_INTEGER:
{
GtkAccessibleValueEnumCtor ctor =
(GtkAccessibleValueEnumCtor) cstate->ctor;
- int value_ = g_value_get_enum (value);
+ int value = g_value_get_int (value_);
- res = (* ctor) (value_);
+ if (ctor == NULL)
+ res = gtk_int_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
GtkAccessibleValueNumberCtor ctor =
(GtkAccessibleValueNumberCtor) cstate->ctor;
- double value_ = g_value_get_double (value);
+ double value = g_value_get_double (value_);
- res = (* ctor) (value_);
+ if (ctor == NULL)
+ res = gtk_number_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
GtkAccessibleValueStringCtor ctor =
(GtkAccessibleValueStringCtor) cstate->ctor;
- const char *value_ = g_value_get_string (value);
+ const char *value = g_value_get_string (value_);
- res = (* ctor) (value_);
+ if (ctor == NULL)
+ res = gtk_string_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
- case GTK_ACCESSIBLE_COLLECT_REF:
+ case GTK_ACCESSIBLE_COLLECT_REFERENCE:
{
GtkAccessibleValueStringCtor ctor =
(GtkAccessibleValueStringCtor) cstate->ctor;
- gpointer value_ = g_value_get_object (value);
+ gpointer value = g_value_get_object (value_);
- res = (* ctor) (value_);
+ if (ctor == NULL)
+ res = gtk_reference_accessible_value_new (value);
+ else
+ res = (* ctor) (value);
}
break;
+ case GTK_ACCESSIBLE_COLLECT_UNDEFINED:
case GTK_ACCESSIBLE_COLLECT_INVALID:
default:
- g_critical ("Unknown value type for accessible state “%s”", cstate->name);
+ g_critical ("Unknown type for accessible state “%s”", cstate->name);
break;
}
return res;
}
+/*< private >
+ * gtk_accessible_value_collect_for_state:
+ * @state: a #GtkAccessibleState
+ * @args: a `va_list` reference
+ *
+ * Collects and consumes the next item in the @args variadic arguments list,
+ * and returns a #GtkAccessibleValue for it.
+ *
+ * Returns: (transfer full): a #GtkAccessibleValue
+ */
+GtkAccessibleValue *
+gtk_accessible_value_collect_for_state (GtkAccessibleState state,
+ va_list *args)
+{
+ const GtkAccessibleCollect *cstate = &collect_states[state];
+
+ return gtk_accessible_value_collect_valist (cstate, args);
+}
+
+/*< private >
+ * gtk_accessible_value_collect_for_state_value:
+ * @state: a #GtkAccessibleState
+ * @value: a #GValue
+ *
+ * Retrieves the value stored inside @value and returns a #GtkAccessibleValue
+ * for the given @state.
+ *
+ * Returns: (transfer full): a #GtkAccessibleValue
+ */
+GtkAccessibleValue *
+gtk_accessible_value_collect_for_state_value (GtkAccessibleState state,
+ const GValue *value)
+{
+ const GtkAccessibleCollect *cstate = &collect_states[state];
+
+ return gtk_accessible_value_collect_value (cstate, value);
+}
+
/*< private >
* gtk_accessible_value_get_default_for_property:
* @property: a #GtkAccessibleProperty
return gtk_autocomplete_accessible_value_new (GTK_ACCESSIBLE_AUTOCOMPLETE_NONE);
case GTK_ACCESSIBLE_PROPERTY_ORIENTATION:
- return gtk_orientation_accessible_value_new (GTK_ORIENTATION_HORIZONTAL);
+ return gtk_undefined_accessible_value_new ();
case GTK_ACCESSIBLE_PROPERTY_SORT:
return gtk_sort_accessible_value_new (GTK_ACCESSIBLE_SORT_NONE);
default:
- g_critical ("Unknown value for accessible state “%s”", cstate->name);
+ g_critical ("Unknown value for accessible property “%s”", cstate->name);
break;
}
{
const GtkAccessibleCollect *cstate = &collect_props[property];
- GtkAccessibleValue *res = NULL;
-
- switch (cstate->ctype)
- {
- case GTK_ACCESSIBLE_COLLECT_BOOLEAN:
- {
- GtkAccessibleValueBooleanCtor ctor =
- (GtkAccessibleValueBooleanCtor) cstate->ctor;
-
- gboolean value = va_arg (*args, gboolean);
-
- res = (* ctor) (value);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_INT:
- {
- GtkAccessibleValueIntCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
-
- int value = va_arg (*args, int);
-
- res = (* ctor) (value);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_TRISTATE:
- {
- GtkAccessibleValueTristateCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
-
- int value = va_arg (*args, int);
-
- res = (* ctor) (value);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_ENUM:
- {
- GtkAccessibleValueEnumCtor ctor =
- (GtkAccessibleValueEnumCtor) cstate->ctor;
-
- int value = va_arg (*args, int);
-
- res = (* ctor) (value);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_NUMBER:
- {
- GtkAccessibleValueNumberCtor ctor =
- (GtkAccessibleValueNumberCtor) cstate->ctor;
-
- double value = va_arg (*args, double);
-
- res = (* ctor) (value);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_STRING:
- {
- GtkAccessibleValueStringCtor ctor =
- (GtkAccessibleValueStringCtor) cstate->ctor;
-
- const char *value = va_arg (*args, char*);
-
- res = (* ctor) (value);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_REF:
- {
- GtkAccessibleValueStringCtor ctor =
- (GtkAccessibleValueStringCtor) cstate->ctor;
-
- gpointer value = va_arg (*args, gpointer);
-
- res = (* ctor) (value);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_INVALID:
- default:
- g_critical ("Unknown type for accessible state “%s”", cstate->name);
- break;
- }
-
- return res;
+ return gtk_accessible_value_collect_valist (cstate, args);
}
/*< private >
{
const GtkAccessibleCollect *cstate = &collect_props[property];
- GtkAccessibleValue *res = NULL;
-
- switch (cstate->ctype)
- {
- case GTK_ACCESSIBLE_COLLECT_BOOLEAN:
- {
- GtkAccessibleValueBooleanCtor ctor =
- (GtkAccessibleValueBooleanCtor) cstate->ctor;
-
- gboolean value_ = g_value_get_boolean (value);
-
- res = (* ctor) (value_);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_INT:
- {
- GtkAccessibleValueIntCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
-
- int value_ = g_value_get_int (value);
-
- res = (* ctor) (value_);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_TRISTATE:
- {
- GtkAccessibleValueTristateCtor ctor =
- (GtkAccessibleValueIntCtor) cstate->ctor;
-
- int value_ = g_value_get_int (value);
-
- res = (* ctor) (value_);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_ENUM:
- {
- GtkAccessibleValueEnumCtor ctor =
- (GtkAccessibleValueEnumCtor) cstate->ctor;
-
- int value_ = g_value_get_enum (value);
-
- res = (* ctor) (value_);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_NUMBER:
- {
- GtkAccessibleValueNumberCtor ctor =
- (GtkAccessibleValueNumberCtor) cstate->ctor;
-
- double value_ = g_value_get_double (value);
-
- res = (* ctor) (value_);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_STRING:
- {
- GtkAccessibleValueStringCtor ctor =
- (GtkAccessibleValueStringCtor) cstate->ctor;
-
- const char *value_ = g_value_get_string (value);
-
- res = (* ctor) (value_);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_REF:
- {
- GtkAccessibleValueStringCtor ctor =
- (GtkAccessibleValueStringCtor) cstate->ctor;
-
- gpointer value_ = g_value_get_object (value);
-
- res = (* ctor) (value_);
- }
- break;
-
- case GTK_ACCESSIBLE_COLLECT_INVALID:
- default:
- g_critical ("Unknown value type for accessible state “%s”", cstate->name);
- break;
- }
-
- return res;
+ return gtk_accessible_value_collect_value (cstate, value);
}
/* }}} */
}
static const GtkAccessibleValueClass GTK_UNDEFINED_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_UNDEFINED,
.type_name = "GtkUndefinedAccessibleValue",
.instance_size = sizeof (GtkAccessibleValue),
.print = gtk_undefined_accessible_value_print,
};
-static GtkAccessibleValue undefined_value = {
- >K_UNDEFINED_ACCESSIBLE_VALUE, 1
-};
+static GtkAccessibleValue undefined_value =
+ GTK_ACCESSIBLE_VALUE_INIT (>K_UNDEFINED_ACCESSIBLE_VALUE);
GtkAccessibleValue *
gtk_undefined_accessible_value_new (void)
return gtk_accessible_value_ref (&undefined_value);
}
+int
+gtk_undefined_accessible_value_get (const GtkAccessibleValue *value)
+{
+ g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_VALUE_UNDEFINED);
+ g_return_val_if_fail (value->value_class == >K_UNDEFINED_ACCESSIBLE_VALUE,
+ GTK_ACCESSIBLE_VALUE_UNDEFINED);
+
+ return GTK_ACCESSIBLE_VALUE_UNDEFINED;
+}
+
/* }}} */
/* {{{ Boolean values */
}
static const GtkAccessibleValueClass GTK_BOOLEAN_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_BOOLEAN,
.type_name = "GtkBooleanAccessibleValue",
.instance_size = sizeof (GtkBooleanAccessibleValue),
.equal = gtk_boolean_accessible_value_equal,
};
static GtkBooleanAccessibleValue boolean_values[] = {
- { { >K_BOOLEAN_ACCESSIBLE_VALUE, 1 }, FALSE },
- { { >K_BOOLEAN_ACCESSIBLE_VALUE, 1 }, TRUE },
+ { GTK_ACCESSIBLE_VALUE_INIT (>K_BOOLEAN_ACCESSIBLE_VALUE), FALSE },
+ { GTK_ACCESSIBLE_VALUE_INIT (>K_BOOLEAN_ACCESSIBLE_VALUE), TRUE },
};
GtkAccessibleValue *
typedef struct {
GtkAccessibleValue parent;
- int value;
+ GtkAccessibleTristate value;
} GtkTristateAccessibleValue;
static gboolean
gtk_tristate_accessible_value_equal (const GtkAccessibleValue *value_a,
const GtkAccessibleValue *value_b)
{
- const GtkTristateAccessibleValue *tri_a = (GtkTristateAccessibleValue *) value_a;
- const GtkTristateAccessibleValue *tri_b = (GtkTristateAccessibleValue *) value_b;
+ const GtkTristateAccessibleValue *self_a = (GtkTristateAccessibleValue *) value_a;
+ const GtkTristateAccessibleValue *self_b = (GtkTristateAccessibleValue *) value_b;
- return tri_a->value == tri_b->value;
+ return self_a->value == self_b->value;
}
static void
switch (self->value)
{
- case 0:
+ case GTK_ACCESSIBLE_TRISTATE_FALSE:
g_string_append (buffer, "false");
break;
- case 1:
+ case GTK_ACCESSIBLE_TRISTATE_TRUE:
g_string_append (buffer, "true");
break;
- case -1:
- g_string_append (buffer, "undefined");
+ case GTK_ACCESSIBLE_TRISTATE_MIXED:
+ g_string_append (buffer, "mixed");
break;
default:
}
}
-static const GtkAccessibleValueClass GTK_EXPANDED_ACCESSIBLE_VALUE = {
- .type_name = "GtkExpandedAccessibleValue",
+static const GtkAccessibleValueClass GTK_TRISTATE_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_TRISTATE,
+ .type_name = "GtkTristateAccessibleValue",
.instance_size = sizeof (GtkTristateAccessibleValue),
.equal = gtk_tristate_accessible_value_equal,
.print = gtk_tristate_accessible_value_print,
};
-static GtkTristateAccessibleValue expanded_values[] = {
- { { >K_EXPANDED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_VALUE_UNDEFINED },
- { { >K_EXPANDED_ACCESSIBLE_VALUE, 1 }, 0 },
- { { >K_EXPANDED_ACCESSIBLE_VALUE, 1 }, 1 },
+static GtkTristateAccessibleValue tristate_values[] = {
+ [GTK_ACCESSIBLE_TRISTATE_FALSE] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_TRISTATE_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_TRISTATE_FALSE
+ },
+ [GTK_ACCESSIBLE_TRISTATE_TRUE] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_TRISTATE_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_TRISTATE_TRUE
+ },
+ [GTK_ACCESSIBLE_TRISTATE_MIXED] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_TRISTATE_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_TRISTATE_MIXED
+ },
};
GtkAccessibleValue *
-gtk_expanded_accessible_value_new (int state)
-{
- int index_;
-
- if (state < 0)
- index_ = 0;
- else if (state == 0)
- index_ = 1;
- else
- index_ = 2;
-
- return gtk_accessible_value_ref ((GtkAccessibleValue *) &expanded_values[index_]);
-}
-
-int
-gtk_expanded_accessible_value_get (const GtkAccessibleValue *value)
+gtk_tristate_accessible_value_new (GtkAccessibleTristate value)
{
- GtkTristateAccessibleValue *self = (GtkTristateAccessibleValue *) value;
-
- g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_VALUE_UNDEFINED);
- g_return_val_if_fail (value->value_class == >K_EXPANDED_ACCESSIBLE_VALUE,
- GTK_ACCESSIBLE_VALUE_UNDEFINED);
-
- return self->value;
+ return gtk_accessible_value_ref ((GtkAccessibleValue *) &tristate_values[value]);
}
-static const GtkAccessibleValueClass GTK_GRABBED_ACCESSIBLE_VALUE = {
- .type_name = "GtkGrabbedAccessibleValue",
- .instance_size = sizeof (GtkTristateAccessibleValue),
- .equal = gtk_tristate_accessible_value_equal,
- .print = gtk_tristate_accessible_value_print,
-};
-
-static GtkTristateAccessibleValue grabbed_values[] = {
- { { >K_GRABBED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_VALUE_UNDEFINED },
- { { >K_GRABBED_ACCESSIBLE_VALUE, 1 }, 0 },
- { { >K_GRABBED_ACCESSIBLE_VALUE, 1 }, 1 },
-};
-
-GtkAccessibleValue *
-gtk_grabbed_accessible_value_new (int state)
+GtkAccessibleTristate
+gtk_tristate_accessible_value_get (const GtkAccessibleValue *value)
{
- int index_;
-
- if (state < 0)
- index_ = 0;
- else if (state == 0)
- index_ = 1;
- else
- index_ = 2;
-
- return gtk_accessible_value_ref ((GtkAccessibleValue *) &grabbed_values[index_]);
-}
+ g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_TRISTATE_FALSE);
+ g_return_val_if_fail (value->value_class == >K_TRISTATE_ACCESSIBLE_VALUE,
+ GTK_ACCESSIBLE_TRISTATE_FALSE);
-int
-gtk_grabbed_accessible_value_get (const GtkAccessibleValue *value)
-{
GtkTristateAccessibleValue *self = (GtkTristateAccessibleValue *) value;
- g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_VALUE_UNDEFINED);
- g_return_val_if_fail (value->value_class == >K_GRABBED_ACCESSIBLE_VALUE,
- GTK_ACCESSIBLE_VALUE_UNDEFINED);
-
- return self->value;
-}
-
-static const GtkAccessibleValueClass GTK_SELECTED_ACCESSIBLE_VALUE = {
- .type_name = "GtkSelectedAccessibleValue",
- .instance_size = sizeof (GtkTristateAccessibleValue),
- .equal = gtk_tristate_accessible_value_equal,
- .print = gtk_tristate_accessible_value_print,
-};
-
-static GtkTristateAccessibleValue selected_values[] = {
- { { >K_SELECTED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_VALUE_UNDEFINED },
- { { >K_SELECTED_ACCESSIBLE_VALUE, 1 }, 0 },
- { { >K_SELECTED_ACCESSIBLE_VALUE, 1 }, 1 },
-};
-
-GtkAccessibleValue *
-gtk_selected_accessible_value_new (int state)
-{
- int index_;
-
- if (state < 0)
- index_ = 0;
- else if (state == 0)
- index_ = 1;
- else
- index_ = 2;
-
- return gtk_accessible_value_ref ((GtkAccessibleValue *) &selected_values[index_]);
-}
-
-int
-gtk_selected_accessible_value_get (const GtkAccessibleValue *value)
-{
- GtkTristateAccessibleValue *self = (GtkTristateAccessibleValue *) value;
-
- g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_VALUE_UNDEFINED);
- g_return_val_if_fail (value->value_class == >K_SELECTED_ACCESSIBLE_VALUE,
- GTK_ACCESSIBLE_VALUE_UNDEFINED);
-
return self->value;
}
int value;
const char *token;
-} GtkEnumAccessibleValue;
+} GtkTokenAccessibleValue;
static gboolean
-gtk_enum_accessible_value_equal (const GtkAccessibleValue *value_a,
- const GtkAccessibleValue *value_b)
+gtk_token_accessible_value_equal (const GtkAccessibleValue *value_a,
+ const GtkAccessibleValue *value_b)
{
- const GtkEnumAccessibleValue *enum_a = (GtkEnumAccessibleValue *) value_a;
- const GtkEnumAccessibleValue *enum_b = (GtkEnumAccessibleValue *) value_b;
+ const GtkTokenAccessibleValue *self_a = (GtkTokenAccessibleValue *) value_a;
+ const GtkTokenAccessibleValue *self_b = (GtkTokenAccessibleValue *) value_b;
- return enum_a->value == enum_b->value;
+ return self_a->value == self_b->value;
}
static void
-gtk_enum_accessible_value_print (const GtkAccessibleValue *value,
- GString *buffer)
+gtk_token_accessible_value_print (const GtkAccessibleValue *value,
+ GString *buffer)
{
- const GtkEnumAccessibleValue *self = (GtkEnumAccessibleValue *) value;
+ const GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
g_string_append (buffer, self->token);
}
-static const GtkAccessibleValueClass GTK_CHECKED_ACCESSIBLE_VALUE = {
- .type_name = "GtkCheckedAccessibleValue",
- .instance_size = sizeof (GtkEnumAccessibleValue),
- .equal = gtk_enum_accessible_value_equal,
- .print = gtk_enum_accessible_value_print,
-};
-
-static GtkEnumAccessibleValue checked_values[] = {
- { { >K_CHECKED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_CHECKED_FALSE, "false" },
- { { >K_CHECKED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_CHECKED_TRUE, "true" },
- { { >K_CHECKED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_PRESSED_UNDEFINED, "undefined" },
- { { >K_CHECKED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_CHECKED_MIXED, "mixed" },
-};
-
-GtkAccessibleValue *
-gtk_checked_accessible_value_new (GtkAccessibleCheckedState state)
-{
- int index_;
-
- switch (state)
- {
- case GTK_ACCESSIBLE_CHECKED_FALSE:
- index_ = 0;
- break;
-
- case GTK_ACCESSIBLE_CHECKED_TRUE:
- index_ = 1;
- break;
-
- case GTK_ACCESSIBLE_CHECKED_UNDEFINED:
- index_ = 2;
- break;
-
- case GTK_ACCESSIBLE_CHECKED_MIXED:
- index_ = 3;
- break;
-
- default:
- g_assert_not_reached ();
- return NULL;
- }
-
- return gtk_accessible_value_ref ((GtkAccessibleValue *) &checked_values[index_]);
-}
-
-GtkAccessibleCheckedState
-gtk_checked_accessible_value_get (const GtkAccessibleValue *value)
-{
- GtkEnumAccessibleValue *self = (GtkEnumAccessibleValue *) value;
-
- g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_CHECKED_UNDEFINED);
- g_return_val_if_fail (value->value_class == >K_CHECKED_ACCESSIBLE_VALUE,
- GTK_ACCESSIBLE_CHECKED_UNDEFINED);
-
- return self->value;
-}
-
-static const GtkAccessibleValueClass GTK_PRESSED_ACCESSIBLE_VALUE = {
- .type_name = "GtkPressedAccessibleValue",
- .instance_size = sizeof (GtkEnumAccessibleValue),
- .equal = gtk_enum_accessible_value_equal,
- .print = gtk_enum_accessible_value_print,
-};
-
-static GtkEnumAccessibleValue pressed_values[] = {
- { { >K_PRESSED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_PRESSED_FALSE, "false" },
- { { >K_PRESSED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_PRESSED_TRUE, "true" },
- { { >K_PRESSED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_PRESSED_UNDEFINED, "undefined" },
- { { >K_PRESSED_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_PRESSED_MIXED, "mixed" },
-};
-
-GtkAccessibleValue *
-gtk_pressed_accessible_value_new (GtkAccessiblePressedState state)
-{
- int index_;
-
- switch (state)
- {
- case GTK_ACCESSIBLE_PRESSED_FALSE:
- index_ = 0;
- break;
-
- case GTK_ACCESSIBLE_PRESSED_TRUE:
- index_ = 1;
- break;
-
- case GTK_ACCESSIBLE_PRESSED_UNDEFINED:
- index_ = 2;
- break;
-
- case GTK_ACCESSIBLE_PRESSED_MIXED:
- index_ = 3;
- break;
-
- default:
- g_assert_not_reached ();
- return NULL;
- }
-
- return gtk_accessible_value_ref ((GtkAccessibleValue *) &pressed_values[index_]);
-}
-
-GtkAccessiblePressedState
-gtk_pressed_accessible_value_get (const GtkAccessibleValue *value)
-{
- GtkEnumAccessibleValue *self = (GtkEnumAccessibleValue *) value;
-
- g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_PRESSED_UNDEFINED);
- g_return_val_if_fail (value->value_class == >K_PRESSED_ACCESSIBLE_VALUE,
- GTK_ACCESSIBLE_PRESSED_UNDEFINED);
-
- return self->value;
-}
-
static const GtkAccessibleValueClass GTK_INVALID_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
.type_name = "GtkInvalidAccessibleValue",
- .instance_size = sizeof (GtkEnumAccessibleValue),
- .equal = gtk_enum_accessible_value_equal,
- .print = gtk_enum_accessible_value_print,
+ .instance_size = sizeof (GtkTokenAccessibleValue),
+ .equal = gtk_token_accessible_value_equal,
+ .print = gtk_token_accessible_value_print,
};
-static GtkEnumAccessibleValue invalid_values[] = {
- { { >K_INVALID_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_INVALID_FALSE, "false" },
- { { >K_INVALID_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_INVALID_TRUE, "true" },
- { { >K_INVALID_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_INVALID_GRAMMAR, "grammar" },
- { { >K_INVALID_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_INVALID_SPELLING, "spelling" },
+static GtkTokenAccessibleValue invalid_values[] = {
+ [GTK_ACCESSIBLE_INVALID_FALSE] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_INVALID_FALSE, "false"
+ },
+ [GTK_ACCESSIBLE_INVALID_TRUE] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_INVALID_TRUE, "true"
+ },
+ [GTK_ACCESSIBLE_INVALID_GRAMMAR] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_INVALID_GRAMMAR, "grammar"
+ },
+ [GTK_ACCESSIBLE_INVALID_SPELLING] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_INVALID_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_INVALID_SPELLING, "spelling"
+ },
};
GtkAccessibleValue *
GtkAccessibleInvalidState
gtk_invalid_accessible_value_get (const GtkAccessibleValue *value)
{
- GtkEnumAccessibleValue *self = (GtkEnumAccessibleValue *) value;
+ GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_INVALID_FALSE);
g_return_val_if_fail (value->value_class == >K_INVALID_ACCESSIBLE_VALUE,
}
static const GtkAccessibleValueClass GTK_AUTOCOMPLETE_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
.type_name = "GtkAutocompleteAccessibleValue",
- .instance_size = sizeof (GtkEnumAccessibleValue),
- .equal = gtk_enum_accessible_value_equal,
- .print = gtk_enum_accessible_value_print,
+ .instance_size = sizeof (GtkTokenAccessibleValue),
+ .equal = gtk_token_accessible_value_equal,
+ .print = gtk_token_accessible_value_print,
};
-static GtkEnumAccessibleValue autocomplete_values[] = {
- { { >K_AUTOCOMPLETE_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_AUTOCOMPLETE_NONE, "none" },
- { { >K_AUTOCOMPLETE_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE, "inline" },
- { { >K_AUTOCOMPLETE_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_AUTOCOMPLETE_LIST, "list" },
- { { >K_AUTOCOMPLETE_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH, "both" },
+static GtkTokenAccessibleValue autocomplete_values[] = {
+ [GTK_ACCESSIBLE_AUTOCOMPLETE_NONE] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_AUTOCOMPLETE_NONE, "none"
+ },
+ [GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE, "inline"
+ },
+ [GTK_ACCESSIBLE_AUTOCOMPLETE_LIST] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_AUTOCOMPLETE_LIST, "list"
+ },
+ [GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_AUTOCOMPLETE_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH, "both"
+ },
};
GtkAccessibleValue *
GtkAccessibleAutocomplete
gtk_autocomplete_accessible_value_get (const GtkAccessibleValue *value)
{
- GtkEnumAccessibleValue *self = (GtkEnumAccessibleValue *) value;
+ GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_AUTOCOMPLETE_NONE);
g_return_val_if_fail (value->value_class == >K_AUTOCOMPLETE_ACCESSIBLE_VALUE,
}
static const GtkAccessibleValueClass GTK_ORIENTATION_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
.type_name = "GtkOrientationAccessibleValue",
- .instance_size = sizeof (GtkEnumAccessibleValue),
- .equal = gtk_enum_accessible_value_equal,
- .print = gtk_enum_accessible_value_print,
+ .instance_size = sizeof (GtkTokenAccessibleValue),
+ .equal = gtk_token_accessible_value_equal,
+ .print = gtk_token_accessible_value_print,
};
-static GtkEnumAccessibleValue orientation_values[] = {
- { { >K_ORIENTATION_ACCESSIBLE_VALUE, 1 }, GTK_ORIENTATION_HORIZONTAL, "horizontal" },
- { { >K_ORIENTATION_ACCESSIBLE_VALUE, 1 }, GTK_ORIENTATION_VERTICAL, "vertical" },
- { { >K_ORIENTATION_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_VALUE_UNDEFINED, "undefined" },
+static GtkTokenAccessibleValue orientation_values[] = {
+ [GTK_ORIENTATION_HORIZONTAL] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_ORIENTATION_ACCESSIBLE_VALUE), GTK_ORIENTATION_HORIZONTAL, "horizontal"
+ },
+ [GTK_ORIENTATION_VERTICAL] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_ORIENTATION_ACCESSIBLE_VALUE), GTK_ORIENTATION_VERTICAL, "vertical"
+ },
};
GtkAccessibleValue *
gtk_orientation_accessible_value_new (GtkOrientation value)
{
- switch (value)
- {
- case GTK_ORIENTATION_HORIZONTAL:
- return gtk_accessible_value_ref ((GtkAccessibleValue *) &orientation_values[0]);
-
- case GTK_ORIENTATION_VERTICAL:
- return gtk_accessible_value_ref ((GtkAccessibleValue *) &orientation_values[1]);
-
- default:
- g_assert_not_reached ();
- break;
- }
-
- return NULL;
+ return gtk_accessible_value_ref ((GtkAccessibleValue *) &orientation_values[value]);
}
GtkOrientation
gtk_orientation_accessible_value_get (const GtkAccessibleValue *value)
{
- GtkEnumAccessibleValue *self = (GtkEnumAccessibleValue *) value;
+ GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
- g_return_val_if_fail (value != NULL, GTK_ORIENTATION_HORIZONTAL);
+ g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_VALUE_UNDEFINED);
g_return_val_if_fail (value->value_class == >K_ORIENTATION_ACCESSIBLE_VALUE,
- GTK_ORIENTATION_HORIZONTAL);
+ GTK_ACCESSIBLE_VALUE_UNDEFINED);
return self->value;
}
static const GtkAccessibleValueClass GTK_SORT_ACCESSIBLE_VALUE = {
+ .type = GTK_ACCESSIBLE_VALUE_TYPE_TOKEN,
.type_name = "GtkSortAccessibleValue",
- .instance_size = sizeof (GtkEnumAccessibleValue),
- .equal = gtk_enum_accessible_value_equal,
- .print = gtk_enum_accessible_value_print,
+ .instance_size = sizeof (GtkTokenAccessibleValue),
+ .equal = gtk_token_accessible_value_equal,
+ .print = gtk_token_accessible_value_print,
};
-static GtkEnumAccessibleValue sort_values[] = {
- { { >K_SORT_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_SORT_NONE, "none" },
- { { >K_SORT_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_SORT_ASCENDING, "ascending" },
- { { >K_SORT_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_SORT_DESCENDING, "descending" },
- { { >K_SORT_ACCESSIBLE_VALUE, 1 }, GTK_ACCESSIBLE_SORT_OTHER, "other" },
+static GtkTokenAccessibleValue sort_values[] = {
+ [GTK_ACCESSIBLE_SORT_NONE] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_SORT_NONE, "none"
+ },
+ [GTK_ACCESSIBLE_SORT_ASCENDING] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_SORT_ASCENDING, "ascending"
+ },
+ [GTK_ACCESSIBLE_SORT_DESCENDING] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_SORT_DESCENDING, "descending"
+ },
+ [GTK_ACCESSIBLE_SORT_OTHER] = {
+ GTK_ACCESSIBLE_VALUE_INIT (>K_SORT_ACCESSIBLE_VALUE), GTK_ACCESSIBLE_SORT_OTHER, "other"
+ },
};
GtkAccessibleValue *
GtkAccessibleSort
gtk_sort_accessible_value_get (const GtkAccessibleValue *value)
{
- GtkEnumAccessibleValue *self = (GtkEnumAccessibleValue *) value;
+ GtkTokenAccessibleValue *self = (GtkTokenAccessibleValue *) value;
g_return_val_if_fail (value != NULL, GTK_ACCESSIBLE_SORT_NONE);
g_return_val_if_fail (value->value_class == >K_SORT_ACCESSIBLE_VALUE,
projects / gtk4.git / commitdiff